package com.topcent.tioxyc.controller;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.topcent.tioxyc.constants.KeyConstant;
import com.topcent.tioxyc.pojo.CostBudget;
import com.topcent.tioxyc.pojo.Customer;
import com.topcent.tioxyc.pojo.Department;
import com.topcent.tioxyc.pojo.vo.*;
import com.topcent.tioxyc.util.ApiClient;
import com.topcent.tioxyc.util.ConnmeUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.Header;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.Month;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author: 陈百万
 * @date: 2025/9/5 17:52
 * @Description: 费用单-预算大项目【固定费】
 */
@Slf4j
@RestController
public class CcCostOrderDataController {

    @GetMapping("costBudgetMonthlyStatistics")
    public String costBudgetMonthlyStatistics() {
        String appId = "665fbebb30a77df3f2d3d47d";
        String entryId = "68b8f8bad231151e6cc8a785";

        List<CostBudget> costBudgets = new ArrayList<>();
        Header[] headers = ConnmeUtils.createHeaders();
        Map<String, Object> parameter = new HashMap<>();
        parameter.put("app_id", appId);
        parameter.put("entry_id", entryId);
        boolean fale = true;
        String zh = "";
        do {
            if (!zh.isEmpty()) {
                parameter.put("data_id", zh);
            }
            parameter.put("limit", 100);
            String jsonSale = JSONUtil.toJsonStr(parameter);
            JSONObject jdySale = ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/app/entry/data/list", headers, jsonSale);
            String data = jdySale.getStr("data");
            JSONArray objects = JSONUtil.parseArray(data);
            List<CostBudget> list = JSONUtil.toList(objects, CostBudget.class);
            if (list.size() == 100) {
                zh = list.getLast().get_id();
            } else {
                fale = false;
            }
            costBudgets.addAll(list);
        } while (fale);

        // 对execl表的预算数据进行分组【固定费】方法
        List<FixedBudget> fixedBudgets = processBudgetData(costBudgets);

        // 获取费用单数据拆分后的数据
        List<CostOrderFeeVO> payInfoList = selectDataCost();
        List<CostOrderFeeVO.payInfo> dataPayInfoCost = selectDataPayInfoCost(payInfoList);
        // 对上面两个数组进行匹配数据
        matchAndCalculate(fixedBudgets ,dataPayInfoCost);
        // 删除【固定费】表单
        //批量删除简道云数据
        ConnmeUtils.selectAndDeleteList(headers, "665fbebb30a77df3f2d3d47d", "68b8fd53800c31f0bf6131f5", "");
        // 新增到【固定费】表单
        for (FixedBudget fixedBudget : fixedBudgets){
            Map<String, Object> parameterFix = new HashMap<>();
            parameterFix.put("app_id", "665fbebb30a77df3f2d3d47d");
            parameterFix.put("entry_id", "68b8fd53800c31f0bf6131f5");
            parameterFix.put("data", ConnmeUtils.convertEntityToMap(fixedBudget));
            fixedBudget.set_id(null);
            String jsonSale = JSONUtil.toJsonStr(parameterFix);
            ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/app/entry/data/create", headers, jsonSale);
        }

        // 删除【累计实际费用】表单
        //批量删除简道云数据
        ConnmeUtils.selectAndDeleteList(headers, "665fbebb30a77df3f2d3d47d", "68d4a3f561fd393b761f73ed", "");
        // 处理费用单数据，按财年自动分组并累加（支持任意财年）
        List<ActualCostResult> actualCostResults = calculateActualCost(payInfoList, null);
        // 新增到【累计实际费用】表单
        for (ActualCostResult actualCostResult : actualCostResults){
            Map<String, Object> parameterCostResult = new HashMap<>();
            parameterCostResult.put("app_id", "665fbebb30a77df3f2d3d47d");
            parameterCostResult.put("entry_id", "68d4a3f561fd393b761f73ed");
            parameterCostResult.put("data", ConnmeUtils.convertEntityToMap(actualCostResult));
            actualCostResult.set_id(null);
            String jsonSale = JSONUtil.toJsonStr(parameterCostResult);
            ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/app/entry/data/create", headers, jsonSale);
        }

        return "插入【固定费】新数据："+ fixedBudgets.size();
    }


    // 分组按当月统计财年内的累计值（财年：当年7月至次年6月）
    public List<FixedBudget> processBudgetData(List<CostBudget> costBudgetList) {
        // 1. 先过滤出费用类型为"固定费"的数据
        List<CostBudget> fixedCostList = costBudgetList.stream()
                .filter(cost -> "固定费".equals(cost.get_widget_1756952762313()))
                .toList();

        // 2. 按科目编码 + 预算部门 分组
        Map<String, List<CostBudget>> groupMap = fixedCostList.stream()
                .collect(Collectors.groupingBy(detail -> detail.get_widget_1756952762307() + "_" + detail.get_widget_1756952762311().getDept_no()));

        List<FixedBudget> resultList = new ArrayList<>();
        LocalDate currentDate = LocalDate.now();
        String currentYearMonth = currentDate.format(DateTimeFormatter.ofPattern("yyyy-MM"));

        // 3. 确定当前财年的起始和结束日期（例如：2025-07-01至2026-06-30）
        LocalDate fiscalYearStart = getFiscalYearStart(currentDate);
        LocalDate fiscalYearEnd = getFiscalYearEnd(currentDate);

        // 4. 遍历分组，计算符合条件的金额
        for (Map.Entry<String, List<CostBudget>> entry : groupMap.entrySet()) {
            String key = entry.getKey();
            String subjectCode = key.split("_")[0];
            String budgetDept = key.split("_")[1];
            List<CostBudget> groupDetails = entry.getValue();

            BigDecimal sumAmount = BigDecimal.ZERO;

            for (CostBudget detail : groupDetails) {
                LocalDate detailDate = detail.get_widget_1756952762310().plusDays(1);

                // 筛选条件：
                // 1. 在当前财年范围内（>= 财年开始 且 <= 财年结束）
                // 2. 在当月及之前（<= 当前日期）
                if (detailDate.isAfter(fiscalYearStart.minusDays(1))  // >= 财年开始（减1天避免边界问题）
                        && detailDate.isBefore(fiscalYearEnd.plusDays(1))  // <= 财年结束（加1天避免边界问题）
                        && detailDate.isBefore(currentDate.plusDays(1))) { // <= 当前月份

                    sumAmount = sumAmount.add(detail.get_widget_1756952762309().abs());
                }
            }

            // 5. 生成结果数据
            FixedBudget groupedBudget = new FixedBudget();
            groupedBudget.set_widget_1756953937797(subjectCode);
            groupedBudget.set_widget_1756953937801(currentYearMonth);
            groupedBudget.set_widget_1756953937802(Integer.valueOf(budgetDept));
            groupedBudget.set_widget_1756953937800(sumAmount);
            resultList.add(groupedBudget);
        }
        return resultList;
    }

    /**
     * 获取当前日期所在财年的开始日期（7月1日）
     * 例：2025年8月 → 2025-07-01；2026年3月 → 2025-07-01
     */
    private LocalDate getFiscalYearStart(LocalDate currentDate) {
        int year = currentDate.getMonthValue() >= 7
                ? currentDate.getYear()
                : currentDate.getYear() - 1;
        return LocalDate.of(year, 7, 1);
    }

    /**
     * 获取当前日期所在财年的结束日期（6月30日）
     * 例：2025年8月 → 2026-06-30；2026年3月 → 2026-06-30
     */
    private LocalDate getFiscalYearEnd(LocalDate currentDate) {
        int year = currentDate.getMonthValue() >= 7
                ? currentDate.getYear() + 1
                : currentDate.getYear();
        return LocalDate.of(year, 6, 30);
    }

    // 获取费用单数据
    public List<CostOrderFeeVO> selectDataCost() {
        String appId = "665fbebb30a77df3f2d3d47d";
        String entryId = "665fbee388d8faa4b491f649";

        List<CostOrderFeeVO> costOrderFeeVOList = new ArrayList<>();
        Header[] headers = ConnmeUtils.createHeaders();
        Map<String, Object> parameter = new HashMap<>();
        parameter.put("app_id", appId);
        parameter.put("entry_id", entryId);

        /*Map<String, Object> filter = new HashMap<>();
        filter.put("rel", "and");
        Map<String, Object> cond = new HashMap<>();
        cond.put("field", "flowState");
        cond.put("type", "flowstate");
        cond.put("method", "eq");
        List<Integer> values = new ArrayList<>();
        values.add(1);
        cond.put("value", values);
        List<Map<String, Object>> conds = new ArrayList<>();
        conds.add(cond);
        filter.put("cond", conds);
        parameter.put("filter", filter);*/

        boolean fale = true;
        String zh = "";
        do {
            if (!zh.isEmpty()) {
                parameter.put("data_id", zh);
            }
            parameter.put("limit", 100);
            String jsonSale = JSONUtil.toJsonStr(parameter);
            JSONObject jdySale = ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/app/entry/data/list", headers, jsonSale);
            String data = jdySale.getStr("data");
            JSONArray objects = JSONUtil.parseArray(data);
            List<CostOrderFeeVO> list = JSONUtil.toList(objects, CostOrderFeeVO.class);
            if (list.size() == 100) {
                zh = list.getLast().get_id();
            } else {
                fale = false;
            }
            costOrderFeeVOList.addAll(list);
        } while (fale);
        return costOrderFeeVOList;
    }

    // 分析费用单数据
    public List<CostOrderFeeVO.payInfo> selectDataPayInfoCost(List<CostOrderFeeVO> costOrderFeeVOList) {
        // -------------------------- 核心拆分逻辑 start --------------------------
        List<CostOrderFeeVO.payInfo> payInfoList = new ArrayList<>();
        // 1. 遍历所有总数据（CostOrderFeeVO）
        for (CostOrderFeeVO totalData : costOrderFeeVOList) {
            // 2. 获取总数据的公共字段：部门no、过账日期（防御空指针）
            String deptNo = totalData.get_widget_1737096027488() != null
                    ? totalData.get_widget_1737096027488().getDept_no()
                    : null;
            LocalDate postingDate = totalData.get_widget_1724133651423();

            // 3. 获取当前总数据的子数据列表（避免子数据为null导致空指针）
            List<CostOrderFeeVO.payInfo> childPayInfos = totalData.get_widget_1717552286301();
            if (childPayInfos == null || childPayInfos.isEmpty()) {
                continue; // 无子数据，直接跳过当前总数据
            }

            // 4. 遍历子数据，赋值+处理金额后加入结果列表
            for (CostOrderFeeVO.payInfo child : childPayInfos) {
                // 赋值总数据的部门no
                child.setDept_no(deptNo);
                // 赋值总数据的过账日期
                child.setPostingDate(postingDate);
                // 金额取正：null设为0，负数转正数
                BigDecimal amount = child.get_widget_1717568393615();
                child.set_widget_1717568393615(amount == null ? BigDecimal.ZERO : amount.abs());

                // 子数据加入结果列表
                payInfoList.add(child);
            }
        }
        // -------------------------- 核心拆分逻辑 end --------------------------
        return payInfoList;
    }


    /**
     * 匹配预算与费用数据，计算累计发生金额（仅用年月匹配，复用已有财年方法）
     */
    public void matchAndCalculate(List<FixedBudget> fixedBudgets, List<CostOrderFeeVO.payInfo> payInfoList) {
        // 1. 获取当前财年范围和当前月份
        LocalDate currentDate = LocalDate.now();
        LocalDate fiscalStart = getFiscalYearStart(currentDate); // 财年开始日期（如2025-01-01）
        LocalDate fiscalEnd = getFiscalYearEnd(currentDate);     // 财年结束日期（如2025-12-31）
        LocalDate currentMonthEnd = currentDate.with(TemporalAdjusters.lastDayOfMonth()); // 本月最后一天（截止日期）

        // 2. 预处理费用数据：按【总账科目+部门】分组，累计本财年内截止到本月的金额
        Map<String, BigDecimal> costSumMap = new HashMap<>();
        for (CostOrderFeeVO.payInfo pay : payInfoList) {
            // 过滤关键信息不全或金额无效的数据
            if (!isValidPayInfo(pay)) {
                continue;
            }

            // 处理过账日期（加1天逻辑保持不变）
            LocalDate postingDate = pay.getPostingDate().plusDays(1);

            // 核心过滤条件：仅保留【财年内】且【不晚于当前月份】的数据
            if (postingDate.isBefore(fiscalStart)          // 早于财年开始
                    || postingDate.isAfter(fiscalEnd)          // 晚于财年结束
                    || postingDate.isAfter(currentMonthEnd)) { // 晚于当前月份（超截止时间）
                continue;
            }

            // 生成匹配键：仅【科目+部门】（移除年月维度）
            String key = pay.get_widget_1721007075246() + "_" + pay.getDept_no();

            // 累加金额（确保为正数，如需处理负数可加.abs()）
            BigDecimal amount = pay.get_widget_1717568393615();
            costSumMap.put(key, costSumMap.getOrDefault(key, BigDecimal.ZERO).add(amount));
        }

        // 3. 为预算数据赋值累计发生金额（本财年截止到本月的合计）
        for (FixedBudget budget : fixedBudgets) {
            // 过滤无效预算数据
            if (!isValidFixedBudget(budget)) {
                budget.set_widget_1756954464270(BigDecimal.ZERO);
                continue;
            }

            // 生成预算侧匹配键：【科目+部门】（与费用侧保持一致）
            String key = budget.get_widget_1756953937797() + "_" + budget.get_widget_1756953937802();

            // 赋值累计金额（从汇总结果中获取，无匹配则为0）
            budget.set_widget_1756954464270(costSumMap.getOrDefault(key, BigDecimal.ZERO));
        }
    }


    /**
     * 校验费用单数据是否有效（关键字段非空）
     */
    private boolean isValidPayInfo(CostOrderFeeVO.payInfo payInfo) {
        return payInfo.get_widget_1721007075246() != null    // 总账科目非空
                && payInfo.getDept_no() != null                  // 部门no非空
                && payInfo.getPostingDate() != null              // 过账日期非空
                && payInfo.get_widget_1717568393615() != null;   // 金额非空
    }

    /**
     * 校验预算数据是否有效（关键字段非空）
     */
    private boolean isValidFixedBudget(FixedBudget budget) {
        return budget.get_widget_1756953937797() != null    // 科目编码非空
                && budget.get_widget_1756953937802() != null    // 预算部门非空
                && budget.get_widget_1756953937801() != null;   // 当前月份（yyyy-MM）非空
    }

    /**
     * 将预算的年月字符串（yyyy-MM）转为LocalDate（默认当月1日，用于财年校验）
     */
    private LocalDate parseBudgetYearMonth(String yearMonthStr) {
        try {
            // 拼接当月1日，转为完整日期（如"2025-09" → 2025-09-01）
            return LocalDate.parse(yearMonthStr + "-01", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        } catch (DateTimeParseException e) {
            // 格式错误（如"2025/09"），返回null表示无效
            return null;
        }
    }


    /**
     * 处理费用单数据，按财年自动分组并累加（支持任意财年）
     * @param costOrderFeeVOList 原始费用单数据
     * @param targetDate 目标日期（用于确定需要计算的财年，null则默认当前日期）
     * @return 按财年和分组条件整理的结果
     */
    public List<ActualCostResult> calculateActualCost(List<CostOrderFeeVO> costOrderFeeVOList, LocalDate targetDate) {
        Header[] headers = ConnmeUtils.createHeaders();
        // 获取销售部门信息
        Map<String ,Object> cond =new HashMap<>();
        cond.put("dept_no", 1);
        cond.put("has_child", true);
        JSONObject deptResult = ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/corp/department/list", headers, JSONUtil.toJsonStr(cond));
        String data = deptResult.getStr("departments");
        JSONArray objects = JSONUtil.parseArray(data);
        List<DepartmentVO> deptList = JSONUtil.toList(objects, DepartmentVO.class);

        Map<String, Integer> deptMap = deptList.stream()
                .collect(Collectors.toMap(DepartmentVO::getName, DepartmentVO::getDept_no, (v1, v2) -> v1));

        // 目标日期默认取当前日期
        LocalDate currentDate = Optional.ofNullable(targetDate).orElse(LocalDate.now());

        Map<String, ExpenseTypeVO> expenseTypeList = getExpenseTypeList(headers);

        // 1. 预处理数据，获取整理后的payInfo列表
        List<CostOrderFeeVO.payInfo> payInfoList = preprocessData(costOrderFeeVOList);

        // 2. 确定需要计算的财年范围（当前财年）
        // 若需计算多个财年，可传入财年列表（如[2025, 2026]）并循环处理
        LocalDate fiscalStart = getFiscalYearStart(currentDate);
        LocalDate fiscalEnd = getFiscalYearEnd(currentDate);

        // 计算截止日期：当前月份的第一天（如2025-09-26 → 2025-09-01）
        LocalDate calculateEndDate = currentDate.withDayOfMonth(1);

        // 3. 按「财年+3个分组字段」进行分组累加
        Map<String, ActualCostResult> groupResultMap = new HashMap<>();

        for (CostOrderFeeVO.payInfo payInfo : payInfoList) {
            LocalDate postingDate = payInfo.getPostingDate();
            if (postingDate == null) continue;
            // 计算当前数据所属的财年
            LocalDate dataFiscalStart = getFiscalYearStart(postingDate);
            LocalDate dataFiscalEnd = getFiscalYearEnd(postingDate);

            // 过滤条件：仅处理「目标财年」且「≤本月第一天」的数据
            boolean isTargetFiscalYear = dataFiscalStart.equals(fiscalStart) && dataFiscalEnd.equals(fiscalEnd);
            boolean isWithinCurrentMonth = postingDate.isBefore(calculateEndDate.plusDays(1));
            if (!isTargetFiscalYear || !isWithinCurrentMonth) {
                continue;
            }

            // 构建分组键（财年标识+3个分组字段）
            String fiscalYearTag = getFiscalYearTag(dataFiscalStart); // 财年标识（如"2025-2026"）
            String groupKey = buildGroupKey(fiscalYearTag, payInfo);

            // 累加金额并更新结果
            updateGroupResult(groupResultMap, groupKey, payInfo, calculateEndDate, fiscalYearTag, deptMap, expenseTypeList);
        }

        return new ArrayList<>(groupResultMap.values());
    }

    /**
     * 预处理数据，提取并格式化payInfo
     */
    private List<CostOrderFeeVO.payInfo> preprocessData(List<CostOrderFeeVO> costOrderFeeVOList) {
        List<CostOrderFeeVO.payInfo> payInfoList = new ArrayList<>();

        for (CostOrderFeeVO totalData : costOrderFeeVOList) {
            // 提取报销部门no
            String deptNo = Optional.ofNullable(totalData.get_widget_1737096027488())
                    .map(Department::getDept_no)
                    .orElse(null);

            // 提取过账日期并转换为当月第一天
            LocalDate postingDate = totalData.get_widget_1724133651423();
            if (postingDate == null) continue;
            LocalDate firstDayOfMonth = postingDate.withDayOfMonth(1);

            // 处理子数据
            List<CostOrderFeeVO.payInfo> childPayInfos = totalData.get_widget_1717552286301();
            if (childPayInfos == null || childPayInfos.isEmpty()) continue;

            for (CostOrderFeeVO.payInfo child : childPayInfos) {
                child.setDept_no(deptNo);
                child.setPostingDate(firstDayOfMonth);
                // 金额处理：null转0，负数取绝对值
                BigDecimal amount = Optional.ofNullable(child.get_widget_1717568393615())
                        .orElse(BigDecimal.ZERO)
                        .abs();
                child.set_widget_1717568393615(amount);

                payInfoList.add(child);
            }
        }

        return payInfoList;
    }

    /**
     * 构建分组键（包含财年标识，避免跨财年数据冲突）
     */
    private String buildGroupKey(String fiscalYearTag, CostOrderFeeVO.payInfo payInfo) {
        String costOwnerDept = Optional.ofNullable(payInfo.get_widget_1721461935882())
                .orElse("未知")
                .trim();
        String generalLedgerAccount = Optional.ofNullable(payInfo.get_widget_1721007075246())
                .orElse("未知")
                .trim();
        String reimbursementDeptNo = Optional.ofNullable(payInfo.getDept_no())
                .orElse("未知")
                .trim();

        // 分组键格式：财年标识|费用归属部门|总账科目|报销部门no
        return String.join("|", fiscalYearTag, costOwnerDept, generalLedgerAccount, reimbursementDeptNo);
    }

    /**
     * 更新分组结果（累加金额并设置字段）
     */
    private void updateGroupResult(Map<String, ActualCostResult> resultMap,
                                   String groupKey,
                                   CostOrderFeeVO.payInfo payInfo,
                                   LocalDate calculateEndDate,
                                   String fiscalYearTag, Map<String, Integer> deptMap, Map<String, ExpenseTypeVO> expenseTypeVOMap) {
        ActualCostResult result = resultMap.get(groupKey);
        if (result == null) {
            result = new ActualCostResult();
            // 设置分组字段
            result.set_widget_1758766069063(payInfo.get_widget_1721007075246()); // 科目编码=总账科目
            result.set_widget_1758766069064(deptMap.get(payInfo.get_widget_1721461935882())); // 收益部门
            result.set_widget_1758766069067(parseDeptNo(payInfo.getDept_no())); // 预算部门
            result.set_widget_1758766069066(calculateEndDate); // 日期=本月第一天
            ExpenseTypeVO expenseTypeVO = expenseTypeVOMap.get(payInfo.get_widget_1721007075246());
            if(ObjectUtil.isNotEmpty(expenseTypeVO)){
                result.set_widget_1758766069069(expenseTypeVO.get_widget_1758528510652()); // 费用类型
                result.set_widget_1758766069068(expenseTypeVO.get_widget_1721007024211()); // 科目名称（可补充）
            }

            resultMap.put(groupKey, result);
        }

        // 累加金额（处理空值和负数）
        BigDecimal currentTotal = Optional.ofNullable(result.get_widget_1758766069065())
                .orElse(BigDecimal.ZERO); // 当前累计值为空时默认0

        BigDecimal addAmount = Optional.ofNullable(payInfo.get_widget_1717568393615())
                .orElse(BigDecimal.ZERO) // 待加金额为空时默认0
                .abs(); // 确保为正数

        // 累加后设置新值
        result.set_widget_1758766069065(currentTotal.add(addAmount));
    }

    /**
     * 生成财年标识（如2025-07-01至2026-06-30 → "2025-2026"）
     */
    private String getFiscalYearTag(LocalDate fiscalStart) {
        return fiscalStart.getYear() + "-" + (fiscalStart.getYear() + 1);
    }

    /**
     * 部门字符串转数字（适配Integer类型字段）
     */
    private Integer parseDeptNo(String deptStr) {
        if (deptStr == null || deptStr.trim().isEmpty() || "未知".equals(deptStr)) {
            return 0;
        }
        try {
            return Integer.parseInt(deptStr.replaceAll("\\D", "")); // 提取数字部分
        } catch (NumberFormatException e) {
            return 0;
        }
    }

    /**
     * 获取拓臣费用报销类型表单数据
     */
    private Map<String, ExpenseTypeVO> getExpenseTypeList(Header[] headers) {
        String appId = "665fbebb30a77df3f2d3d47d";
        String entryId = "66947bb004c63ab7b79d61c1";

        List<ExpenseTypeVO> expenseTypeVOList = new ArrayList<>();
        Map<String, Object> parameter = new HashMap<>();
        parameter.put("app_id", appId);
        parameter.put("entry_id", entryId);

        boolean fale = true;
        String zh = "";
        do {
            if (!zh.isEmpty()) {
                parameter.put("data_id", zh);
            }
            parameter.put("limit", 100);
            String jsonSale = JSONUtil.toJsonStr(parameter);
            JSONObject jdySale = ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/app/entry/data/list", headers, jsonSale);
            String data = jdySale.getStr("data");
            JSONArray objects = JSONUtil.parseArray(data);
            List<ExpenseTypeVO> list = JSONUtil.toList(objects, ExpenseTypeVO.class);
            if (list.size() == 100) {
                zh = list.getLast().get_id();
            } else {
                fale = false;
            }
            expenseTypeVOList.addAll(list);
        } while (fale);
        // 将列表转换为以总账科目为key的Map
        Map<String, ExpenseTypeVO> resultMap = new HashMap<>();
        for (ExpenseTypeVO vo : expenseTypeVOList) {
            // 确保key不为null时才放入Map
            if (vo.get_widget_1721007024210() != null) {
                resultMap.put(vo.get_widget_1721007024210(), vo);
            }
        }
        return resultMap;
    }
}
